package com.module.ble.repo

import com.module.ble.db.HealthExaManager
import com.module.ble.db.table.UserSleepInfo
import com.module.ble.db.table.UserSportRecord
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.flatMapLatest
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.launch

/**
 * 作者：sosou
 * <p>
 * 版本：1.0
 * <p>
 * 创建日期：2025/04/16
 * <p>
 * 描述：仓库类，所有相关的数据操作都在此类中进行，数据库的增、删、改、查操作
 * <p>
 * 修订历史：
 */
class SportRecordRepo private constructor() {

    private val refreshTrigger = MutableStateFlow(0)

    companion object {
        val instance by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) { SportRecordRepo() }
    }

    private val dao = HealthExaManager.mSportRecordDao

    private val scope = CoroutineScope(Dispatchers.IO)

    /**
     * 查找该时间数据
     */
    fun findByTime(time :Long): UserSportRecord? {
        //数据库查找所有数据
        return dao?.findByTime(time)
    }

    /**
     * 查找所有数据
     */
    fun findAll(): List<UserSportRecord>? {
        //数据库查找所有数据
        return dao?.findAll()
    }

    /**
     * 查找所有未上传数据
     */
    fun findAllNotUp(): List<UserSportRecord>? {
        //数据库查找所有数据
        return dao?.findAllNotUp()
    }

    /**
     * 查找所有数据
     */
    @OptIn(ExperimentalCoroutinesApi::class)
    fun findAllFlow(): Flow<List<UserSportRecord>> = refreshTrigger.flatMapLatest { dao?.findAllFlow() ?: flowOf(emptyList())}

    /**
     * 根据传入时间戳查询该时间戳当天内的所有运动记录数据
     * @param timestamp 指定的时间戳（毫秒）
     * @return 当天所有的运动记录数据列表，如果没有数据则返回空列表
     */
    fun findAllByDay(timestamp: Long): List<UserSportRecord> {
        return dao?.findAllByDay(timestamp) ?: emptyList()
    }

    /**
     * 根据传入时间戳查询该时间戳当天内的所有运动记录数据（Flow版本）
     * @param timestamp 指定的时间戳（毫秒）
     * @return Flow<List<UserSportRecord>> 当天所有的运动记录数据
     */
    @OptIn(ExperimentalCoroutinesApi::class)
    fun findAllByDayFlow(timestamp: Long): Flow<List<UserSportRecord>> {
        return refreshTrigger.flatMapLatest { dao?.findAllByDayFlow(timestamp) ?: flowOf(emptyList()) }
    }

    /**
     * 根据传入ID查询该运动记录数据
     * @param id ID
     * @return 当前ID运动记录数据
     */
    fun findAllById(id: Long): UserSportRecord? {
        return dao?.findAllById(id)
    }

    /**
     * 插入数据
     */
    fun add2DB(data: UserSportRecord?) {
        data?.let { dataIt->
            scope.launch {
                dao?.insertOrUpdate(dataIt)
            }
        }
    }

    fun updateBatch(mList: List<UserSportRecord>, batchSize: Int = 500) {
        if (mList.isNullOrEmpty()) return
        scope.launch {
            // 分批处理
            mList.chunked(batchSize).forEach { batch ->
                dao?.update(batch) // 分配更新
            }
        }
    }

    /**
     * 删除数据库中数据
     */
    private fun del2DB(data: UserSportRecord?) {
        data?.let { dataIt->
            scope.launch {
                dao?.delete(dataIt)
            }
        }
    }

    fun insertDistinct(mList: List<UserSportRecord>, batchSize: Int = 500) {
        if (mList.isNullOrEmpty()) return
        scope.launch {
            // 分批处理
            mList.chunked(batchSize).forEach { batch ->
                dao?.insert(batch) // 直接插入整个批次
            }
        }
    }

    /**
     * 删除数据库中所有数据
     */
    fun deleteAll() {
        scope.launch {
            dao?.deleteAll()
        }
    }

    /**
     * 自动触发 Flow 的更新，进而更新 LiveData
     */
    fun refreshData() {
        refreshTrigger.value += 1
    }

    /**
     *
     */
    fun updateAllSysStatToZero() {
        scope.launch {
            dao?.updateAllSysStatToZero()
        }
    }

    /**
     *
     */
    fun deleteInvalidData() {
        scope.launch {
            dao?.deleteInvalidData()
        }
    }
}